In [1]:
include("hermite_interpolation.jl")
include("polytesting.jl")
include("trigonometric_polynomials.jl")
include("trigtesting.jl")
include("utilities.jl")
include("functiontesting.jl")
importall WGPolyTesting, WGTrigTesting, WGTrigonometricPoly, WGUtilities, WGFunTesting

WARNING: replacing module WGTrigonometricPoly
WARNING: replacing module WGUtilities
WARNING: replacing module WGUtilities
WARNING: replacing module WGUtilities
WARNING: ignoring conflicting import of WGTrigTesting.chebyshev_nodes into Main
In [2]:
using Plotly

Plotly javascript loaded.

To load again call 

init_notebook(true)

Uwaga! Ze względu na rozmiar notatników jupytera i nałożony limit rozmiaru pliku wysyłanego w portalu Przedmioty, zostały umieszczone pojedyncze wykorzystania funkcji testujących - zachęcam do wykorzystania zakomentowanego kodu oraz zmiany parametrów takich jak N1, r (przedział interpolacji zależnie od testu) czy rodzaju węzłów (bez argumentu mamy węzły równoodległe, można wykorzystać też argument "chebyshev" pokazany w paru testach dający węzły Czebyszewa).

Testy wielomianów w węzłach równoodległych

Wielomiany wejściowe w testach są tworzone losowo, a ich stopień jest liczbą z przedziału $ 2N_1 \leq deg(w) \leq 3N_1 $. Wielomian interpolacyjny Hermite'a przebiega w $N_1$ węzłach oraz ich pierwszych pochodnych, natomiast klasyczny wielomian interpolacyjny przebiega przez $2N_1$ równoodległych węzłów.

In [3]:
N1 = 4
r = 1
domain = linspace(BigFloat(-r),BigFloat(r),5000)
possible_coefficients = linspace(BigFloat(-4),BigFloat(4),100)
testcase = generate_polynomial_for_hermite(linspace(BigFloat(-r),BigFloat(r),N1), linspace(BigFloat(-r),BigFloat(r),2*N1), (2N1):1:(3N1), possible_coefficients)
polynomial = testcase[1]
hermite = get_hermite_NewtonPoly(testcase[2]...)
newton = get_NewtonPoly(testcase[3]...)
0
#Plotly.plot([Plotly.scatter(x=domain, y=[horner(polynomial, x)[1] for x in domain], name="Wielomian wejściowy"), 
#            Plotly.scatter(x=domain, y=[newtonPolyval(hermite, x)  for x in domain ], name="Interpolacja Hermite'a"),
#            Plotly.scatter(x=domain, y=[newtonPolyval(newton, x)  for x in domain ], name="Interpolacja Newtona")])
Out[3]:
0

Czyli wielomiany H oraz N mają stopień $2N_1 - 1$.

Poniżej, będziemy analogicznie sprawdzać 100 losowych wielomianów, a na wykresie przedstawimy średnią arytmetyczną błędów wszystkich utworzonych wielomianów dla danego argumentu

In [4]:
domain = linspace(BigFloat(-1),BigFloat(1), 100)
N1 = 10
t = run_polytest(N1)
Plotly.plot([Plotly.scatter(x=domain, y=t[1], name="Hermite Error"), Plotly.scatter(x=domain, y=t[2], name="Newton Error")])
Out[4]:

Testy wielomianów w węzłach Czebyszewa

In [5]:
t = run_polytest(20, "chebyshev")
Plotly.plot([Plotly.scatter(x=domain, y=t[1], name="Hermite Error"), Plotly.scatter(x=domain, y=t[2], name="Newton Error")])
Out[5]:

Testy wielomianów trygonometrycznych w węzłach równoodległych

Teraz będziemy testować funkcje postaci $f(x) = \sum_{n=0}^{m} a_n\cos(nx) + b_n\sin(nx)$ analogicznie do zwykłych wielomianów.

In [6]:
N1 = 5
domain = linspace(BigFloat(-1),BigFloat(1),5000)
testcase = generate_trigpoly_for_hermite(linspace(BigFloat(-1),BigFloat(1),N1), linspace(BigFloat(-1),BigFloat(1),2*N1), 5:1:15,linspace(BigFloat(-5),BigFloat(5),100))
trig_poly = testcase[1]
hermite = get_hermite_NewtonPoly(testcase[2]...)
newton = get_NewtonPoly(testcase[3]...)
0
#Plotly.plot([Plotly.scatter(x=domain, y=[value(trig_poly, x) for x in domain], name="Funkcja wejściowa"), 
#            Plotly.scatter(x=domain, y=[newtonPolyval(hermite, x)  for x in domain ],name="Interpolacja Hermite'a"),
#            Plotly.scatter(x=domain, y=[newtonPolyval(newton, x)  for x in domain ], name="Interpolacja Newtona")])
Out[6]:
0

W wypadku wielomianów trygonometrycznych będziemy patrzeć na błąd bezwzględny, bowiem wykres błędu względnego "wybucha" właśnie w zerach funkcji $f$ i staje się nieczytelny.

In [7]:
t = run_trigtest(6)
Plotly.plot([Plotly.scatter(x=domain, y=t[1], name="Hermite Error"), Plotly.scatter(x=domain, y=t[2], name="Newton Error")])
Out[7]:

Testy wielomianów trygonometrycznych w węzłach Czebyszewa

In [8]:
t = run_trigtest(10, "chebyshev")
Plotly.plot([Plotly.scatter(x=domain, y=t[1], name="Hermite Error"), Plotly.scatter(x=domain, y=t[2], name="Newton Error")])
Out[8]:

Testy funkcji Rungego

Będziemy testować następującą funkcję - $f(x) = \frac{1}{1 + 25x^2} $. Sprawdzimy, czy tak jak przewidywaliśmy przy testach wielomianów, efekt Rungego nadal występuje

In [9]:
f(x) = 1./(1.+25.*x.^2)
df(x) = -(50.*x)./(25.*x.^2 .+ 1).^2
ddf(x) =  (50.*(75.*x.^2 .- 1))./(25.*x.^2 .+ 1).^3
Out[9]:
ddf (generic function with 1 method)
In [10]:
domain =  linspace(BigFloat(-1),BigFloat(1), 2000)
N1 = 10
level = 3
_,hermite,newton = test_function(f,df,ddf, linspace(BigFloat(-1),BigFloat(1), N1), linspace(BigFloat(-1),BigFloat(1), level*N1), level)
Plotly.plot([Plotly.scatter(x=domain, y=f.(domain), name="Funkcja Rungego"), 
             Plotly.scatter(x=domain, y=[newtonPolyval(hermite, x)  for x in domain ],name="Interpolacja Hermite'a"),
             Plotly.scatter(x=domain, y=[newtonPolyval(newton, x)  for x in domain ], name="Interpolacja Newtona")])
Out[10]:
In [11]:
#    hermite_errors = []
#   newton_errors = []
#   for x in domain
#       exact_value = f(x)
#       push!(hermite_errors, abs(exact_value - newtonPolyval(hermite, x))/abs(exact_value))
#       push!(newton_errors ,abs(exact_value - newtonPolyval(newton, x))/abs(exact_value))
#   end
#   Plotly.plot([Plotly.scatter(x=domain, y=hermite_errors, name="Błędy interpolacji Hermite'a"), 
#                Plotly.scatter(x=domain, y=newton_errors, name="Błędy interpolacji Newtona")])

Testy funkcji $e^{x^2}$

In [12]:
f(x) = e.^(x.^2)
df(x) = 2.*x.*e.^(x.^2)
ddf(x) = 2*e.^(x.^2).*(2x.^2 .+ 1)
Out[12]:
ddf (generic function with 1 method)
In [13]:
r = 2
domain =  linspace(BigFloat(-r),BigFloat(r), 2000)
N1 = 4
level = 3
_,hermite,newton = test_function(f,df,ddf, linspace(BigFloat(-r),BigFloat(r), N1), linspace(BigFloat(-r),BigFloat(r), level*N1), level)
Plotly.plot([Plotly.scatter(x=domain, y=f.(domain), name="Funkcja wejściowa"), 
             Plotly.scatter(x=domain, y=[newtonPolyval(hermite, x)  for x in domain ],name="Interpolacja Hermite'a"),
             Plotly.scatter(x=domain, y=[newtonPolyval(newton, x)  for x in domain ], name="Interpolacja Newtona")])
Out[13]:
In [14]:
#hermite_errors = []
#newton_errors = []
#for x in domain
#   exact_value = f(x)
#   push!(hermite_errors, abs(exact_value - newtonPolyval(hermite, x))/abs(exact_value))
#   push!(newton_errors ,abs(exact_value - newtonPolyval(newton, x))/abs(exact_value))
#end
#Plotly.plot([Plotly.scatter(x=domain, y=hermite_errors, name="Błędy interpolacji Hermite'a"), 
#            Plotly.scatter(x=domain, y=newton_errors, name="Błędy interpolacji Newtona")])

Testy funkcji $e^{-x^2}$

In [15]:
f(x) = e.^(-x.^2)
df(x) = -2.*x.*e.^(-x.^2)
ddf(x) = 2*e.^(-x.^2).*(2x.^2 .- 1)
Out[15]:
ddf (generic function with 1 method)
In [16]:
N1 = 5
level = 2
domain = linspace(BigFloat(-2),BigFloat(2), 1000)
_,hermite,newton = test_function(f,df,ddf, linspace(BigFloat(-2),BigFloat(2), N1), linspace(BigFloat(-2),BigFloat(2), level*N1), level)
Plotly.plot([Plotly.scatter(x=domain, y=f.(domain), name="Funkcja wejściowa"), 
             Plotly.scatter(x=domain, y=[newtonPolyval(hermite, x)  for x in domain ],name="Interpolacja Hermite'a"),
             Plotly.scatter(x=domain, y=[newtonPolyval(newton, x)  for x in domain ], name="Interpolacja Newtona")])
Out[16]:
In [17]:
#hermite_errors = []
#newton_errors = []
#for x in domain
#    exact_value = f(x)
#    push!(hermite_errors, abs(exact_value - newtonPolyval(hermite, x))/abs(exact_value))
#    push!(newton_errors ,abs(exact_value - newtonPolyval(newton, x))/abs(exact_value))
#end
#Plotly.plot([Plotly.scatter(x=domain, y=hermite_errors, name="Błędy interpolacji Hermite'a"), 
#            Plotly.scatter(x=domain, y=newton_errors, name="Błędy interpolacji Newtona")])